// 验证工具函数

/**
 * 验证邮箱格式
 * @param {string} email 邮箱地址
 * @returns {boolean} 是否为有效邮箱
 */
export function isValidEmail(email) {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

/**
 * 验证手机号格式
 * @param {string} phone 手机号
 * @returns {boolean} 是否为有效手机号
 */
export function isValidPhone(phone) {
  const phoneRegex = /^1[3-9]\d{9}$/
  return phoneRegex.test(phone)
}

/**
 * 验证身份证号格式
 * @param {string} idCard 身份证号
 * @returns {boolean} 是否为有效身份证号
 */
export function isValidIdCard(idCard) {
  const idCardRegex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
  return idCardRegex.test(idCard)
}

/**
 * 验证URL格式
 * @param {string} url URL地址
 * @returns {boolean} 是否为有效URL
 */
export function isValidUrl(url) {
  try {
    new URL(url)
    return true
  } catch {
    return false
  }
}

/**
 * 验证密码强度
 * @param {string} password 密码
 * @returns {object} 密码强度信息
 */
export function validatePassword(password) {
  const result = {
    isValid: false,
    strength: 0,
    message: ''
  }

  if (!password) {
    result.message = '密码不能为空'
    return result
  }

  if (password.length < 6) {
    result.message = '密码长度至少6位'
    return result
  }

  let strength = 0

  // 包含小写字母
  if (/[a-z]/.test(password)) strength++

  // 包含大写字母
  if (/[A-Z]/.test(password)) strength++

  // 包含数字
  if (/\d/.test(password)) strength++

  // 包含特殊字符
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) strength++

  result.strength = strength

  if (strength < 2) {
    result.message = '密码强度太弱'
  } else if (strength < 3) {
    result.message = '密码强度一般'
    result.isValid = true
  } else {
    result.message = '密码强度很强'
    result.isValid = true
  }

  return result
}

/**
 * 验证用户名格式
 * @param {string} username 用户名
 * @returns {object} 验证结果
 */
export function validateUsername(username) {
  const result = {
    isValid: false,
    message: ''
  }

  if (!username) {
    result.message = '用户名不能为空'
    return result
  }

  if (username.length < 3) {
    result.message = '用户名长度至少3位'
    return result
  }

  if (username.length > 20) {
    result.message = '用户名长度不能超过20位'
    return result
  }

  if (!/^[a-zA-Z0-9_]+$/.test(username)) {
    result.message = '用户名只能包含字母、数字和下划线'
    return result
  }

  result.isValid = true
  result.message = '用户名格式正确'
  return result
}

/**
 * 验证必填字段
 * @param {any} value 值
 * @param {string} fieldName 字段名
 * @returns {object} 验证结果
 */
export function validateRequired(value, fieldName = '字段') {
  const result = {
    isValid: false,
    message: ''
  }

  if (value === null || value === undefined || value === '') {
    result.message = `${fieldName}不能为空`
    return result
  }

  if (typeof value === 'string' && value.trim() === '') {
    result.message = `${fieldName}不能为空`
    return result
  }

  result.isValid = true
  return result
}

/**
 * 验证数字范围
 * @param {number} value 数值
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @param {string} fieldName 字段名
 * @returns {object} 验证结果
 */
export function validateNumberRange(value, min, max, fieldName = '数值') {
  const result = {
    isValid: false,
    message: ''
  }

  if (typeof value !== 'number') {
    result.message = `${fieldName}必须是数字`
    return result
  }

  if (value < min) {
    result.message = `${fieldName}不能小于${min}`
    return result
  }

  if (value > max) {
    result.message = `${fieldName}不能大于${max}`
    return result
  }

  result.isValid = true
  return result
}

/**
 * 验证字符串长度
 * @param {string} value 字符串
 * @param {number} minLength 最小长度
 * @param {number} maxLength 最大长度
 * @param {string} fieldName 字段名
 * @returns {object} 验证结果
 */
export function validateStringLength(value, minLength, maxLength, fieldName = '字符串') {
  const result = {
    isValid: false,
    message: ''
  }

  if (typeof value !== 'string') {
    result.message = `${fieldName}必须是字符串`
    return result
  }

  if (value.length < minLength) {
    result.message = `${fieldName}长度不能少于${minLength}个字符`
    return result
  }

  if (value.length > maxLength) {
    result.message = `${fieldName}长度不能超过${maxLength}个字符`
    return result
  }

  result.isValid = true
  return result
}

/**
 * 验证表单数据
 * @param {object} data 表单数据
 * @param {object} rules 验证规则
 * @returns {object} 验证结果
 */
export function validateForm(data, rules) {
  const errors = {}
  let isValid = true

  for (const field in rules) {
    const rule = rules[field]
    const value = data[field]

    // 必填验证
    if (rule.required) {
      const requiredResult = validateRequired(value, rule.label || field)
      if (!requiredResult.isValid) {
        errors[field] = requiredResult.message
        isValid = false
        continue
      }
    }

    // 跳过空值的其他验证
    if (!value && !rule.required) continue

    // 邮箱验证
    if (rule.email && !isValidEmail(value)) {
      errors[field] = '邮箱格式不正确'
      isValid = false
    }

    // 手机号验证
    if (rule.phone && !isValidPhone(value)) {
      errors[field] = '手机号格式不正确'
      isValid = false
    }

    // 字符串长度验证
    if (rule.minLength || rule.maxLength) {
      const lengthResult = validateStringLength(
        value,
        rule.minLength || 0,
        rule.maxLength || Infinity,
        rule.label || field
      )
      if (!lengthResult.isValid) {
        errors[field] = lengthResult.message
        isValid = false
      }
    }

    // 自定义验证
    if (rule.validator && typeof rule.validator === 'function') {
      const customResult = rule.validator(value, data)
      if (!customResult.isValid) {
        errors[field] = customResult.message
        isValid = false
      }
    }
  }

  return {
    isValid,
    errors
  }
}
